perm filename PUP2[AP,DBL] blob
sn#071952 filedate 1973-11-12 generic text, type T, neo UTF8
(FILECREATED "12-NOV-73 12:54:58" PUP2)
(DEFINEQ
(A:BEING:ORDER
[LAMBDA (B1 B2)
(LESSP (FAST:BEING:COMPLEX B1)
(FAST:BEING:COMPLEX B2])
(AD
[LAMBDA (L)
(SETQ PUP2FNS (SORT (APPEND PUP2FNS L)))
(SETQ PUP2FNS (INTERSECTION PUP2FNS PUP2FNS))
(MAKEFILE (QUOTE PUP2])
(ADD:BEING
[LAMBDA (B)
(PUT B IDEN B)
(SET B B)
(PUT B BEING T)
[FOR X IN (CDR SET:OF:BEING:PARTS) DO (PROGN (PRIN1 X)
(PRIN1 " ")
(PUT B X (READ]
(PRIN1 "*** FINISHED ***")
(SETQ SET:OF:BEINGS (CONS B SET:OF:BEINGS))
[EVAL (LIST (QUOTE DEFINEQ)
(LIST B (LIST (QUOTE LAMBDA)
(GETP B EXPLICIT:ARGS)
(LIST TRY:BEING B (CONS (QUOTE LIST)
(GETP B
EXPLICIT:ARGS]
(AD (LIST B])
(DISK:DUMP
[LAMBDA (FILE STUFF)
(SETQ FILEVARS (MKATOM (CONCAT (MKSTRING FILE)
"VARS")))
(SET FILEVARS (QUOTE (EVERYTHING)))
(SETQ EVERYTHING STUFF)
(MAKEFILE FILE])
(DOT:PROD
[LAMBDA (L1 L1)
(COND
[L1 (PLUS (TIMES (CAR L1)
(CAR L2))
(DOT:PROD (CDR L1)
(CDR L2]
(T 0])
(FAST:BEING:COMPLEX
[LAMBDA (B)
(DOT:PROD (QUOTE (.1 .6 .3))
(GETP B COMPLEXITY:VECTOR])
(FOREACH
[LAMBDA (X IN SET DO ACTION)
(PROG (RESULT)
START:HERE
(COND
((NULL SET)
(RETURN RESULT)))
(SET X (CAR SET))
(SETQ SET (CDR SET))
(SETQ RESULT (EVAL ACTION))
(GO START:HERE])
(MESSAGE
[LAMBDA (M)
(TRY:BEING MESSAGE (LIST M])
(PERMIT:USER:INTERRUPT
[LAMBDA NIL
(COND
(EXPERTISE (PRIN1 "INTERRUPT? "))
(T (PRIN1
"
DO YOU WISH TO INTERRUPT ME NOW, TO ASK ME ABOUT WHAT I'M DOING? ")))
(SELECTQ (RATOM)
(Y (PROCESS:USER:INTERRUPT))
(N NIL)
(PROGN (PRIN1 "
NO, NO. TYPE Y OR N ......... ")
(PERMIT:USER:INTERRUPT])
(POP:DEMONS
[LAMBDA NIL
(MATCHQ (←CURRENT:DEMONS
←←DEMON:STACK)
$DEMON:STACK])
(PROCESS:USER:INTERRUPT
[LAMBDA NIL
(QPROG (RESPONSE ←BC
←BC1
←BC2)
(COND
((NOT EXPERTISE)
(PRINT (APPEND (QUOTE (BEING IS))
B))
(PRIN1 " TYPE ? OR ")))
(PRIN1 " REQUEST: ")
(MATCHQ (←BC
←←BC2)
BEING:STACK)
(MATCHQ ←BC1
(TUPLE))
L
(ATTEMPT [SELECTQ (SETQ RESPONSE (READ))
[? (PRIN1
" YOUR OPTIONS ARE AS FOLLOWS:
QUIT END THE INTERRUPT
BEING PRINT NAME OF CURRENT BEING
DEMONS PRINT SET OF DEMONS CURRENTLY ACTIVE
CONTROL:HISTORY PRINT LIST OF BEINGS IN CONTROL, THE PATH FROM THE
CURRENT BEING BACK TO THE BEGINNING OF THE PROGRAM
OLDER CONSIDER THE BEING WHICH CALLED THE CURRENT ONE
YOUNGER CONSIDER THE BEING WHICH THE CURRENT ONE CALLED
OLDEST CONSIDER THE FIRST BEING IN CONTROL
YOUNGEST CONSIDER THE LAST BEING IN CONTROL
")
(PRIN1
"SPEC:WHY PRINT OUT THE SPECIFIC REASON(S) THAT THIS BEING WAS
CALLED. THIS DIFFERS FROM 'WHY' IN SENSE THAT SPEC:WHY IS
THE REASON GIVEN BY THE CALLER, WHERAS WHY IS THE REASON
STORED WITH THE CURRENT BEING PERMANENTLY.
")
(MAPC SET:OF:BEING:PARTS
(FUNCTION (LAMBDA (Y)
(PRIN1 Y)
(PRIN1 " PRINT OUT ")
(PRIN1 Y)
(PRIN1
" WITH RESPECT TO CURRENT BEING
"]
(QUIT (COND
((NOT EXPERTISE)
(PRIN1 "
END OF INTERRUPT
")))
(RETURN))
(BEING (PRINT $BC))
(CONTROL:HISTORY (PRIN1 $BC1)
(PRIN1 " *** ")
(PRIN1 $BC)
(PRIN1 " *** ")
(PRIN1 $BC2)
(TERPRI))
(DEMONS (PRIN1 $CURRENT:DEMONS)
(PRIN1 "
THE DEMON STACK IS ")
(PRINT $DEMON:STACK))
(OLDER (MATCHQ ←BC1
(TUPLE $$BC1 $BC))
(MATCHQ (←BC
←←BC2)
$BC2)
(PRINT $BC))
(YOUNGER (MATCHQ ←BC2
(TUPLE $BC $$BC2))
(MATCHQ (←←BC1
←BC)
$BC1)
(PRINT $BC))
(OLDEST (MATCHQ (←←BC1
←BC)
BEING:STACK)
(MATCHQ ←BC2
(TUPLE))
(PRINT $BC))
(YOUNGEST (MATCHQ (←BC
←←BC2)
BEING:STACK)
(MATCHQ ←BC1
(TUPLE))
(PRINT $BC))
(COND
((MEMBER RESPONSE NON:EVAL:BEING:PARTS)
(PRINT (GETP $BC RESPONSE)))
[(MEMBER RESPONSE EVAL:BEING:PARTS)
(PRINT (EVAL (GETP $BC RESPONSE]
((NLSETQ (PRINT (EVAL RESPONSE)))
T)
(T (FAIL]
THEN T
ELSE (PRIN1
"
*** ERROR *** IMPOSSIBLE. TYPE ? FOR HELP.
"))
(GO L])
(PULLOUT
[LAMBDA (E L)
(COND
((ATOM L)
L)
((EQUAL E (CAR L))
(CDR L))
(T (CONS (CAR L)
(PULLOUT E (CDR L])
(PUSH:DEMONS
[LAMBDA (NEW:DEMONS)
(MATCHQ ←NEW:DEMO
(SETDIFFERENCE NEW:DEMONS $CURRENT:DEMONS))
(MATCHQ ←DEMON:STACK
(TUPLE $CURRENT:DEMONS $$DEMON:STACK))
(MATCHQ ←CURRENT:DEMONS
(TUPLE $$NEW:DEMO $$CURRENT:DEMONS])
(SATISFY
[LAMBDA (G)
(COND
(G (TRY:BEING SATISFY (LIST G)))
(T T])
(SERVE
[LAMBDA NIL
(TRY:BEING SERVE (LIST])
(SETDIFFERENCE
[LAMBDA (S1 S2)
(COND
((NULL S1)
NIL)
(T (APPEND [COND
((MEMBER (CAR S1)
S2)
NIL)
(T (LIST (CAR S1]
(SETDIFFERENCE (CDR S1)
S2])
(SETINTERSECTION
[LAMBDA (S1 S2)
(INTERSECTION S1 S2])
(SETUNION
[LAMBDA (S1 S2)
(SETQ S1 (APPEND S1 S2))
(INTERSECTION S1 S1])
(START
[LAMBDA (EXPERTISE)
(PROG NIL
(SETQ Y (QUOTE Y))
(SETQ N (QUOTE N))
(SETQ BEING:STACK NIL)
(SETQ BECAUSE NIL)
(MATCHQ ←DEMON:STACK
(TUPLE))
(MATCHQ ←CURRENT:DEMONS
(TUPLE))
(COND
(EXPERTISE (PRIN1 "USER INTERRUPT LEVEL... "))
(T (PRIN1
"HELLO THERE. I AM READY TO START .
HOW OFTEN SHOULD I LET YOU INTERRRUPT ME, TO ASK ME ABOUT WHAT I'M
DOING? TYPE A DIGIT, AS EXPLAINED BELOW:
0 NEVER (ULTIMATE PRODUCTION-RUN MODE)
2 A COUPLE OF TIMES DURING THE COURSE OF WRITING A PROGRAM
4 DURING EACH PHASE OF WRITING A PROGRAM
6 DURING THE WRITING OF EACH NONTRIVIAL SUBFUNCTION OF A PROGRAM
8 DURING EACH PHASE OF WRITING EACH SUBFUNCTION OF A PROGRAM
10 EACH TIME A BEING TRANSFERS CONTROL (ULTIMATE DEBUG MODE)
OK, NOW TYPE A DIGIT... ")))
L [MATCHQ ←PERMANENT:USER:INTERRUPT:DEMONS
(SELECTQ (RATOM)
(0 (CLASS))
(2 (CLASS USER:INTERRUPT:AT:DEBUG
USER:INTERRUPT:AT:END))
(4 (CLASS USER:INTERRUPT:AT:PHASES))
(6 (CLASS USER:INTERRUPT:AT:PHASES
USER:INTERRUPT:AT:CODING))
(8 (CLASS USER:INTERRUPT:AT:PHASES
USER:INTERRUPT:AT:CODING
USER:INTERRUPT:AT:ADAPTING))
(10 (CLASS PERMIT:USER:INTERRUPT))
(AND (PRIN1
"
*** ERROR *** YOU MUST TYPE ONE EVEN INTEGER FROM 0 TO 10
TRY AGAIN:
")
(GO L]
(MATCHQ ←USER:INTERRUPT:DEMONS
$PERMANENT:USER:INTERRUPT:DEMONS)
(SETQ USER:INTERRUPT:COPY:OF:PHASES PROGRAM:WRITING:PHASES)
(SERVE])
(SUBSTITUTE
[LAMBDA (NEW FOR OLD IN LIST:STRUCTURE)
(SET LIST:STRUCTURE (SUBST NEW OLD (EVAL LIST:STRUCTURE])
(TRY:BEING
[LAMBDA (B ARGS)
(EVAL (GETP TRY:BEING EXPLICIT:ARGS:CHECK))
(EVAL (GETP TRY:BEING META:CODE])
(TRY:TO:SATISFY
[LAMBDA (SUBGOAL)
(ATTEMPT (SATISFY SUBGOAL)
THEN T
ELSE (SETQ FINAL:CO:REQ (CONS SUBGOAL FINAL:CO:REQ])
(USER:INTERRUPT:AT:ADAPTING
[LAMBDA (S:EXP)
(COND
((EQUAL B ADAPT:PRECONCEIVED:FUNCTION)
(PERMIT:USER:INTERRUPT)
(MATCHQ (CLASS USER:INTERRUPT:AT:ADAPTING
←←USER:INTERRUPT:DEMONS)
$USER:INTERRUPT:DEMONS])
(USER:INTERRUPT:AT:CODING
[LAMBDA (S:EXP)
(COND
((EQUAL B ENCODE)
(PERMIT:USER:INTERRUPT)
(MATCHQ (CLASS USER:INTERRUPT:AT:CODING ←←USER:INTERRUPT:DEMONS)
$USER:INTERRUPT:DEMONS])
(USER:INTERRUPT:AT:DEBUG
[LAMBDA (S:EXP)
(COND
((EQUAL B CLARIFY:IMPROBABLE:SITUATION)
(PERMIT:USER:INTERRUPT)
(MATCHQ (CLASS USER:INTERRUPT:AT:DEBUG ←←USER:INTERRUPT:DEMONS)
$USER:INTERRUPT:DEMONS])
(USER:INTERRUPT:AT:END
[LAMBDA (S:EXP)
(COND
((EQUAL B OPTIMIZE)
(PERMIT:USER:INTERRUPT)
(MATCHQ (CLASS USER:INTERRUPT:AT:END ←←USER:INTERRUPT:DEMONS)
$USER:INTERRUPT:DEMONS])
(USER:INTERRUPT:AT:PHASES
[LAMBDA (S:EXP)
(COND
((MEMBER B USER:INTERRUPT:COPY:OF:PHASES)
(PERMIT:USER:INTERRUPT)
(SETQ USER:INTERRUPT:COPY:OF:PHASES (PULLOUT B
USER:INTERRUPT:COPY:OF:PHASES])
)
(LISPXPRINT (QUOTE PUP2FNS)
T)
(RPAQQ PUP2FNS
(A:BEING:ORDER AD ADD:BEING DISK:DUMP DOT:PROD
FAST:BEING:COMPLEX FOREACH MESSAGE
PERMIT:USER:INTERRUPT POP:DEMONS
PROCESS:USER:INTERRUPT PULLOUT PUSH:DEMONS
SATISFY SERVE SETDIFFERENCE SETINTERSECTION
SETUNION START SUBSTITUTE TRY:BEING
TRY:TO:SATISFY USER:INTERRUPT:AT:ADAPTING
USER:INTERRUPT:AT:CODING
USER:INTERRUPT:AT:DEBUG USER:INTERRUPT:AT:END
USER:INTERRUPT:AT:PHASES))
(LISPXPRINT (QUOTE PUP2VARS)
T)
[RPAQQ PUP2VARS (SET:OF:BEINGS
BEING NON:EVAL:BEING:PARTS EVAL:BEING:PARTS A:BEING:ORDER
TRY:TO:SATISFY SET:OF:BEING:PARTS PROGRAM:WRITING:PHASES
EVAL (VARS * (APPEND SET:OF:BEINGS SET:OF:BEING:PARTS))
(COMS * (LIST (APPEND (QUOTE (PROP ALL))
SET:OF:BEINGS]
(RPAQQ SET:OF:BEINGS (MESSAGE SERVE SATISFY TRY:BEING))
(RPAQQ BEING BEING)
(RPAQQ NON:EVAL:BEING:PARTS
(IDEN IMPLICIT:ARGS EXPLICIT:ARGS WHEN META:CODE COMMENTS
PRE:REQUISITES CO:REQUISITES POST:REQUISITES
EXPLICIT:ARGS:CHECK DEMONS MAIN:EFFECTS MINOR:EFFECTS
COMPLEXITY:VECTOR GENERALIZATIONS SPECIALIZATIONS
ALTERNATIVES))
(RPAQQ EVAL:BEING:PARTS (WHAT HOW WHY AFFECTS SPEC:WHY))
(RPAQQ A:BEING:ORDER A:BEING:ORDER)
(RPAQQ TRY:TO:SATISFY TRY:TO:SATISFY)
(RPAQQ SET:OF:BEING:PARTS
(IDEN IMPLICIT:ARGS EXPLICIT:ARGS WHAT HOW WHY SPEC:WHY WHEN
META:CODE COMMENTS PRE:REQUISITES CO:REQUISITES
POST:REQUISITES EXPLICIT:ARGS:CHECK DEMONS MAIN:EFFECTS
MINOR:EFFECTS AFFECTS COMPLEXITY:VECTOR GENERALIZATIONS
SPECIALIZATIONS ALTERNATIVES))
(RPAQQ PROGRAM:WRITING:PHASES (OBTAIN:USABLE:INFORMATION
USE:INFORMATION
FILL:IN:UNDEFINED:SECTION
ADAPT:PRECONCIVED:FUNCTION
CLARIFY:IMPROBABLE:SITUATION
FIX:INCORRECT:PIECE
OPTIMIZE))
(RPAQQ EVAL EVAL)
(RPAQQ MESSAGE MESSAGE)
(RPAQQ SERVE SERVE)
(RPAQQ SATISFY SATISFY)
(RPAQQ TRY:BEING TRY:BEING)
(RPAQQ IDEN IDEN)
(RPAQQ IMPLICIT:ARGS IMPLICIT:ARGS)
(RPAQQ EXPLICIT:ARGS EXPLICIT:ARGS)
(RPAQQ WHAT WHAT)
(RPAQQ HOW HOW)
(RPAQQ WHY WHY)
(RPAQQ SPEC:WHY SPEC:WHY)
(RPAQQ WHEN WHEN)
(RPAQQ META:CODE META:CODE)
(RPAQQ COMMENTS COMMENTS)
(RPAQQ PRE:REQUISITES PRE:REQUISITES)
(RPAQQ CO:REQUISITES CO:REQUISITES)
(RPAQQ POST:REQUISITES POST:REQUISITES)
(RPAQQ EXPLICIT:ARGS:CHECK EXPLICIT:ARGS:CHECK)
(RPAQQ DEMONS DEMONS)
(RPAQQ MAIN:EFFECTS MAIN:EFFECTS)
(RPAQQ MINOR:EFFECTS MINOR:EFFECTS)
(RPAQQ AFFECTS AFFECTS)
(RPAQQ COMPLEXITY:VECTOR COMPLEXITY:VECTOR)
(RPAQQ GENERALIZATIONS GENERALIZATIONS)
(RPAQQ SPECIALIZATIONS SPECIALIZATIONS)
(RPAQQ ALTERNATIVES ALTERNATIVES)
(PUTPROPS MESSAGE IDEN MESSAGE
BEING T
IMPLICIT:ARGS NIL
EXPLICIT:ARGS (M)
WHAT (TUPLE GIVE THE USER THE MESSAGE (@ M))
HOW (TUPLE THE USER WILL READ THE MESSAGE
(@ M)
THAT PUP TYPES OUT)
WHY (TUPLE SO THAT THE USER MAY ASSIMILATE THE
INFORMATION IN THE MESSAGE (@ M))
WHEN (((AWARE USER $M)
-200))
META:CODE [PROGN (PRIN1 "PUP: ")
(PRINT M)
(TERPRI)
(ASSERT (LASTRESPONDER PUP))
(DENY (LASTRESONDER USER))
(ASSERT (AWARE USER (@ M)))
(ASSERT (READ USER (@ M]
COMMENTS NIL
PRE:REQUISITES NIL
CO:REQUISITES NIL
POST:REQUISITES NIL
EXPLICIT:ARGS:CHECK T
DEMONS NIL
MAIN:EFFECTS (((AWARE USER ←M)
(MESSAGE $M))
((READ USER ←M)
(MESSAGE $M)))
MINOR:EFFECTS ((LASTRESPONDER PUP))
AFFECTS NIL
COMPLEXITY:VECTOR (0.0 .1 .9 .7)
GENERALIZATIONS (COMMUNICATE I/O)
SPECIALIZATIONS (RESPOND QUERY)
ALTERNATIVES NIL
SPEC:WHY (TUPLE WE CALL THE SIMPLEST BEING WHICH
CAN BRING ABOUT THE EFFECT
(AWARE USER (PUP WANTS ANY TASK)))
NIL (WE CALL THE SIMPLEST BEING WHICH CAN BRING
ABOUT THE EFFECT
(AWARE USER (PUP WANTS ANY TASK))))
(PUTPROPS SERVE IDEN SERVE
IMPLICIT:ARGS NIL
EXPLICIT:ARGS NIL
WHAT (TUPLE DO ANYTHING THE USER ASKS)
HOW (TUPLE GET A TASK FROM THE USER)
WHY (TUPLE FUNDAMENTAL DRIVE TO SERVE THE USER)
WHEN NIL
META:CODE (COND ($DONE (PRINT "WE ARE DONE"))
(T (PRINT "NOPE, NO DONE")
(SERVE)))
COMMENTS ((PRINT "ARE WE DONE (T OR NIL)?? ")
(MATCHQ ←DONE (READ)))
PRE:REQUISITES ((AWARE USER (PUP WANTS ANY TASK)))
CO:REQUISITES NIL
POST:REQUISITES NIL
EXPLICIT:ARGS:CHECK NIL
DEMONS NIL
MAIN:EFFECTS (((ATTEMPTING ←TASK)
(SERVE)))
MINOR:EFFECTS NIL
AFFECTS NIL
COMPLEXITY:VECTOR (.2 .4 .6 .8)
GENERALIZATIONS NIL
SPECIALIZATIONS (WRITE:PROGRAM COUNSEL)
ALTERNATIVES (IGNORE REBEL)
BEING T
SPEC:WHY NIL
NIL NIL)
(PUTPROPS SATISFY IDEN SATISFY
IMPLICIT:ARGS NIL
EXPLICIT:ARGS (G)
WHAT (TUPLE SATISFY THE SIMPLE SUBGOAL
(@ G))
HOW (TUPLE PASS CONTROL TO THE SIMPLEST SUFFICIENT
BEING)
WHY (TUPLE (@ G)
IS A REQUISITE TO BE SATISFIED)
WHEN NIL
META:CODE [COND
((ATTEMPT (IS (@ G))
THEN T)
T)
(T
(PROG
(B:LIST)
(MATCHQ ←G (@ G))
(FOR
B1 IN (PULLOUT SATISFY
SET:OF:BEINGS)
DO
(FOR
X IN (GETP B1 MAIN:EFFECTS)
UNTIL
(ATTEMPT (MATCH (CAR X)
$G)
THEN
(SETQ
B:LIST
(APPEND
(CDR X)
B:LIST)))
DO NIL))
(/SETQ BECAUSE
(TUPLE TUPLE WE CALL THE
SIMPLEST BEING WHICH
CAN BRING ABOUT THE
EFFECT $G))
(FOR X IN (SORT B:LIST
A:BEING:ORDER)
UNTIL
(ATTEMPT (IS $G)
THEN T)
DO
(ATTEMPT (EVAL X)))
(IS $G)
(ASSERT (TUPLE SATISFIED $G]
COMMENTS NIL
PRE:REQUISITES NIL
CO:REQUISITES NIL
POST:REQUISITES NIL
EXPLICIT:ARGS:CHECK T
DEMONS NIL
MAIN:EFFECTS (((SATISFIED ←G)
(SATISFY $G)))
MINOR:EFFECTS NIL
AFFECTS [APPEND
[MAPCAR
(PROG
(B:LIST)
(MATCHQ ←G (@ G))
(FOR
B1 IN (PULLOUT SATISFY
SET:OF:BEINGS)
DO
(FOR X IN (GETP B1 MAIN:EFFECTS)
UNTIL
(ATTEMPT
(MATCH (CAR X)
$G)
THEN
(SETQ B:LIST
(APPEND (CDR X)
B:LIST)))
DO NIL))
(RETURN B:LIST))
(FUNCTION
(LAMBDA
(Y)
(COND
(Y (CONS Y (QUOTE (POSSIBLE:CALLED
]
(QUOTE ((TRY:BEING CALLED)
(SORT CALLED)
(A:BEING:ORDER CALLED]
COMPLEXITY:VECTOR (0.0 .3 .2 .4)
GENERALIZATIONS (SERVE)
SPECIALIZATIONS (TRY:BEING)
ALTERNATIVES (WRITE:PROGRAM
ADAPT:PRECONCEIVED:FUNCTION)
BEING T
SPEC:WHY NIL
NIL NIL)
(PUTPROPS TRY:BEING IDEN TRY:BEING
IMPLICIT:ARGS NIL
EXPLICIT:ARGS (B ARGS)
EXPLICIT:ARGS:CHECK (AND
(EQUAL T (GETP B BEING))
(EQUAL (LENGTH
(GETP B
EXPLICIT:ARGS))
(LENGTH ARGS)))
WHAT (TUPLE CARRY OUT BEING (EVAL B)
WITH ARGUMENTS (EVAL ARGS))
META:CODE (PROG (FINAL:CO:REQ)
(/SETQ BEING:STACK (CONS B
BEING:STACK))
(EVAL (GETP B EXPLICIT:ARGS:CHECK)
)
(MAPC (GETP B PRE:REQUISITES)
SATISFY)
(PUSH:DEMONS (GETP B DEMONS))
(MAPC (GETP B CO:REQUISITES)
TRY:TO:SATISFY)
(MAPC (GETP B COMMENTS)
EVAL)
(PUT B SPEC:WHY BECAUSE)
(/SETQ BECAUSE NIL)
(ASSERT (APPLYING DEMONS)
APPLY
$USER:INTERRUPT:DEMONS)
(EVAL (GETP B META:CODE))
(MAPC FINAL:CO:REQ SATISFY)
(POP:DEMONS)
(MAPC (GETP B POST:REQUISITES)
SATISFY)
(/SETQ BEING:STACK (CDR
BEING:STACK)))
BEING T)
STOP